# 函数级别修复脚本，确保整个函数块有一致的缩进
import os
import shutil

# 文件路径
original_file = r'd:\未知\yolo_apply\video_processing\video_processor.py'
final_backup = r'd:\未知\yolo_apply\video_processing\video_processor.py.final_backup'
temp_file = r'd:\未知\yolo_apply\video_processing\video_processor_function_fixed.py'

# 确保我们使用最终备份
if os.path.exists(final_backup):
    print(f"使用最终备份文件: {final_backup}")
    
    # 读取文件内容
    with open(final_backup, 'r', encoding='utf-8', errors='replace') as f:
        lines = f.readlines()
    
    # 找到问题区域和它所在的函数
    problem_line = None
    function_start = None
    function_end = None
    
    # 首先找到问题区域
    for i, line in enumerate(lines):
        if '# 错误率过高时触发警告和恢复' in line:
            problem_line = i
            break
    
    # 如果找到问题区域，寻找它所在的函数
    if problem_line is not None:
        print(f"找到问题区域在第{problem_line+1}行")
        
        # 向上查找函数定义
        for i in range(problem_line, -1, -1):
            stripped = lines[i].strip()
            if stripped.startswith('def ') and ':' in stripped:
                function_start = i
                print(f"找到函数定义在第{function_start+1}行: {stripped}")
                break
            elif stripped.startswith('class ') and ':' in stripped:
                # 如果没有找到函数，至少找到类定义
                function_start = i
                print(f"找到类定义在第{function_start+1}行: {stripped}")
                break
        
        # 向下查找函数结束
        if function_start is not None:
            # 计算函数定义的缩进
            func_indent = len(lines[function_start]) - len(lines[function_start].lstrip())
            
            # 跟踪缩进级别
            indent_level = func_indent + 4  # 函数内部应该多一级缩进
            
            # 查找函数结束（当缩进级别回到函数定义级别或更低）
            for i in range(function_start + 1, len(lines)):
                current_indent = len(lines[i]) - len(lines[i].lstrip())
                
                # 如果遇到空行，继续
                if not lines[i].strip():
                    continue
                
                # 如果缩进级别等于或小于函数定义级别，且不是注释，可能是函数结束
                if current_indent <= func_indent and not lines[i].lstrip().startswith('#'):
                    function_end = i
                    break
            
            # 如果没有找到明确的结束，设置为文件末尾
            if function_end is None:
                function_end = len(lines)
            
            print(f"函数从第{function_start+1}行到第{function_end+1}行")
            
            # 创建新的文件内容
            new_lines = []
            
            # 添加函数前的内容
            new_lines.extend(lines[:function_start])
            
            # 重写函数部分，确保一致的缩进
            # 首先添加函数定义行
            new_lines.append(lines[function_start])
            
            # 处理函数体
            for i in range(function_start + 1, function_end):
                line = lines[i]
                stripped = line.strip()
                
                # 如果是空行，保持空行
                if not stripped:
                    new_lines.append('\n')
                    continue
                
                # 如果是注释，保持注释但确保缩进
                if stripped.startswith('#'):
                    if '# 错误率过高时触发警告和恢复' in stripped:
                        # 只保留这个注释，跳过其他问题代码
                        new_lines.append(' ' * (func_indent + 4) + stripped + '\n')
                        # 跳过下一行直到找到error_count
                        j = i + 1
                        while j < function_end:
                            if 'error_count = 0' in lines[j]:
                                new_lines.append(' ' * (func_indent + 4) + 'error_count = 0\n')
                                i = j
                                break
                            j += 1
                    else:
                        # 其他注释保持正确缩进
                        new_lines.append(' ' * (func_indent + 4) + stripped + '\n')
                    continue
                
                # 确保代码行有正确的缩进（4个空格一级）
                # 简化版本：统一使用4空格缩进
                new_lines.append(' ' * (func_indent + 4) + stripped + '\n')
            
            # 添加函数后的内容
            new_lines.extend(lines[function_end:])
            
            # 写入临时文件
            with open(temp_file, 'w', encoding='utf-8', newline='\n') as f:
                f.writelines(new_lines)
            
            print(f"已创建函数级别修复的临时文件: {temp_file}")
            
            # 替换原文件
            os.replace(temp_file, original_file)
            print(f"已用函数级别修复的文件替换原文件")
            print("现在让我们再次尝试编译...")
        else:
            print("错误: 无法找到包含问题区域的函数或类定义")
    else:
        print("错误: 无法在文件中找到问题区域")
else:
    print(f"错误: 找不到最终备份文件 {final_backup}")